// pages/result/result.js
Page({
  /**
   * 页面的初始数据
   */
  data: {
    resultType: 'text',
    resultData: {},
    isLiked: false,
    hasDrawnToday: false,
    bonusDrawCount: 0,
    hasSubmittedToday: false,
    historyId: null
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad: function (options) {
    console.log('接收到的options:', options);
    const app = getApp();
    
    // 直接使用接收到的historyId参数
    // 确保historyId是字符串类型，防止类型转换问题
    let historyId = options.historyId !== undefined ? String(options.historyId) : null;
    console.log('接收到的historyId参数:', historyId, '类型:', typeof historyId);
    
    // 检查并处理"undefined"字符串或undefined的情况
    if (historyId === 'undefined' || historyId === 'null') {
      console.warn('接收到无效的historyId，尝试从全局数据获取');
      // 从全局数据中获取historyId作为备选方案
      historyId = app.globalData.drawResult?.historyId || null;
      console.log('从全局数据获取的historyId:', historyId);
    }
    
    this.setData({
      historyId: historyId
    });
    
    console.log('设置后的historyId:', this.data.historyId, '类型:', typeof this.data.historyId);
    
    this.loadResultData();
  },

  /**
   * 加载结果数据
   */
  async loadResultData() {
    const app = getApp();
    
    try {
      wx.showLoading({ title: '加载中...' });
      
      let found = false;
      
      // 获取当前设置的historyId
      const historyId = this.data.historyId;
      console.log('loadResultData中的historyId:', historyId, '类型:', typeof historyId);
      
      // 检查historyId是否有效
      if (!historyId || historyId === 'undefined' || historyId === 'null') {
        console.warn('historyId无效，尝试从全局数据获取');
        // 从全局数据中获取有效的historyId
        if (app.globalData.drawResult && (app.globalData.drawResult.historyId || app.globalData.drawResult.id)) {
          const globalHistoryId = String(app.globalData.drawResult.historyId || app.globalData.drawResult.id);
          console.log('从全局数据获取到historyId:', globalHistoryId);
          this.setData({ historyId: globalHistoryId });
        }
      }
      
      // 增强检查，避免处理无效字符串
      if (this.data.historyId && this.data.historyId !== 'undefined' && this.data.historyId !== 'null') {
        // 先从内存缓存中查找
        if (app.globalData.cachedData && app.globalData.cachedData.drawHistory) {
          // 确保drawHistory是数组类型
          if (!Array.isArray(app.globalData.cachedData.drawHistory)) {
            console.warn('drawHistory不是数组，已重置为空数组');
            app.globalData.cachedData.drawHistory = [];
          }
          
          const historyItem = app.globalData.cachedData.drawHistory.find(item => {
            const itemId = String(item.id);
            const historyIdStr = String(this.data.historyId);
            return itemId === historyIdStr || item.id === parseInt(historyIdStr);
          });
          
          if (historyItem) {
            // 检查数据格式，根据类型统一处理content中的payload
            let formattedContent = historyItem.content;
            let resultType = historyItem.type || 'text';
            
            // 转换结果类型为小写，与wxml模板一致
            if (resultType && typeof resultType === 'string') {
              resultType = resultType.toLowerCase();
            }
            
            if (formattedContent && formattedContent.payload) {
              // 根据内容类型处理不同的数据结构
              if (resultType === 'image') {
                // 清理URL中的反引号和多余空格
                let imageUrl = formattedContent.payload.url || '';
                if (imageUrl) {
                  imageUrl = imageUrl.trim().replace(/[`]/g, '');
                }
                
                formattedContent = {
                  image: imageUrl,
                  text: formattedContent.payload.caption || '图片描述',
                  tags: formattedContent.tags || [],
                  source: formattedContent.source || '系统'
                };
                console.log('处理后的图片数据:', formattedContent);
              } else {
                formattedContent = {
                  title: formattedContent.payload.title || '标题',
                  content: formattedContent.payload.content || formattedContent.payload.body || '内容',
                  tags: formattedContent.tags || [],
                  source: formattedContent.source || '系统'
                };
              }
            }
            
            this.setData({
              resultType: resultType,
              resultData: formattedContent
            });
            found = true;
          }
        }
        
        // 如果缓存中没有，尝试从后端获取详情
        if (!found) {
          await this.fetchResultDetail();
          found = true; // 假设fetchResultDetail成功
        }
      }
      
      // 如果还是没找到，使用全局数据
      if (!found) {
        // 确保全局数据也正确处理payload格式
        let resultData = {
          title: '礼物送达成功',
          content: '一份温暖的惊喜送给努力的你！',
          tags: ['#鼓励', '#温暖'],
          source: '系统'
        };
        
        // 如果全局数据中有结果，并且有payload，正确处理
        if (app.globalData.drawResult && app.globalData.drawResult.content) {
          const globalContent = app.globalData.drawResult.content;
          // 确定内容类型并转换为小写
          let resultType = app.globalData.drawResult.content?.type || app.globalData.drawResultType || 'text';
          if (typeof resultType === 'string') {
            resultType = resultType.toLowerCase();
          }
          
          if (globalContent.payload) {
            // 根据内容类型处理不同的数据结构
            if (resultType === 'image') {
              // 清理URL中的反引号和多余空格
              let imageUrl = globalContent.payload.url || '';
              if (imageUrl) {
                imageUrl = imageUrl.trim().replace(/[`]/g, '');
              }
              
              resultData = {
                image: imageUrl,
                text: globalContent.payload.caption || '图片描述',
                tags: globalContent.tags || [],
                source: globalContent.source || '系统'
              };
              console.log('处理后的全局图片数据:', resultData);
              this.data.resultType = 'image';
            } else {
            resultData = {
              title: globalContent.payload.title || '标题',
              content: globalContent.payload.content || globalContent.payload.body || '内容',
              tags: globalContent.tags || [],
              source: globalContent.source || '系统'
            };
          }
          } else {
            resultData = globalContent;
          }
        }
        
        this.setData({
          resultType: this.data.resultType || app.globalData.drawResultType || 'text',
          resultData: resultData
        });
      }
      
      // 加载用户状态
      this.setData({
        hasDrawnToday: app.globalData.hasDrawnToday || false,
        bonusDrawCount: app.globalData.bonusDrawCount || 0,
        // 简单判断是否已经投稿
        hasSubmittedToday: app.globalData.contributionStatus === 'approved'
      });
      
    } catch (error) {
      console.error('加载结果失败:', error);
      
      // 错误处理：使用默认数据
      this.setData({
        resultType: 'text',
        resultData: {
          title: '网络连接失败',
          content: '请检查网络连接后重试',
          tags: ['#提示'],
          source: '系统'
        }
      });
    } finally {
      wx.hideLoading();
    }
  },

  /**
   * 从后端获取结果详情
   */
  async fetchResultDetail() {
    const apiService = require('../../utils/api.js');
    const app = getApp();
    
    try {
      console.log('fetchResultDetail调用，当前historyId:', this.data.historyId, '类型:', typeof this.data.historyId);
      
      // 确保historyId是字符串类型
      const historyIdStr = String(this.data.historyId);
      console.log('处理后的historyId字符串:', historyIdStr);
      
      // 增强检查historyId有效性
      if (!historyIdStr || historyIdStr === 'undefined' || historyIdStr === 'null' || !historyIdStr.trim()) {
        console.warn('无效的historyId参数，跳过API调用');
        this.setData({
          resultType: 'text',
          resultData: {
            title: '提示',
            content: '暂无法获取详细信息',
            tags: ['#提示'],
            source: '系统'
          }
        });
        return;
      }
      
      console.log('准备调用API获取详情，使用的historyId:', historyIdStr);
      // 调用API获取结果详情，确保传递处理后的字符串形式
      const result = await apiService.getDrawResultDetail(historyIdStr);
      
      if (result && result.success) {
        // 处理content数据格式转换
        let formattedContent = {};
        let resultType = 'text';
        
        if (result.data.content) {
          // 确定内容类型并转换为小写
          resultType = result.data.content?.type || result.data.type || 'text';
          if (typeof resultType === 'string') {
            resultType = resultType.toLowerCase();
          }
          
          // 检查是否存在payload对象（后端API返回格式）
          if (result.data.content.payload) {
            // 根据内容类型处理不同的数据结构
            if (resultType === 'image') {
              // 清理URL中的反引号和多余空格
              let imageUrl = result.data.content.payload.url || '';
              if (imageUrl) {
                imageUrl = imageUrl.trim().replace(/[`]/g, '');
              }
              
              formattedContent = {
                image: imageUrl,
                text: result.data.content.payload.caption || '图片描述',
                tags: result.data.content.tags || [],
                source: result.data.content.source || '系统'
              };
              console.log('处理后的API返回图片数据:', formattedContent);
            } else {
              formattedContent = {
                title: result.data.content.payload.title || '标题',
                content: result.data.content.payload.content || result.data.content.payload.body || '内容',
                tags: result.data.content.tags || [],
                source: result.data.content.source || '系统'
              };
            }
          } else {
            // 直接使用content对象（兼容其他格式）
            formattedContent = result.data.content;
          }
        }
        
        this.setData({
          resultType: resultType,
          resultData: formattedContent
        });
        
        // 更新全局缓存
        if (app.globalData.cachedData && app.globalData.cachedData.drawHistory) {
          // 确保drawHistory是数组类型
          if (!Array.isArray(app.globalData.cachedData.drawHistory)) {
            console.warn('drawHistory不是数组，已重置为空数组');
            app.globalData.cachedData.drawHistory = [];
          }
          
          // 检查是否已存在该记录
          const index = app.globalData.cachedData.drawHistory.findIndex(item => 
            String(item.id) === historyIdStr || String(item.historyId) === historyIdStr
          );
          
          if (index === -1) {
            // 添加到缓存
            app.globalData.cachedData.drawHistory.unshift(result.data);
          }
        }
      }
    } catch (error) {
      console.error('获取结果详情失败:', error);
      // 失败时设置默认数据
      this.setData({
        resultType: 'text',
        resultData: {
          title: '加载失败',
          content: '获取详细信息失败，请稍后重试',
          tags: ['#提示'],
          source: '系统'
        }
      });
    }
  },

  /**
   * 切换点赞状态
   */
  toggleLike: function() {
    this.setData({
      isLiked: !this.data.isLiked
    });
    
    // 这里可以添加点赞的动画效果和逻辑
    if (this.data.isLiked) {
      wx.showToast({
        title: '点赞成功',
        icon: 'success',
        duration: 1500
      });
    }
  },

  /**
   * 分享结果
   */
  shareResult: function() {
    wx.navigateTo({
      url: '../share/share?type=' + this.data.resultType + '&historyId=' + this.data.historyId
    });
  },

  /**
   * 去投稿页面
   */
  goToSubmit: function() {
    wx.navigateTo({
      url: '../submit/submit'
    });
  },

  /**
   * 切换播放状态
   */
  togglePlay: function() {
    // 模拟播放/暂停逻辑
    wx.showToast({
      title: '播放中...',
      icon: 'none',
      duration: 1500
    });
  },

  /**
   * 页面分享配置
   */
  onShareAppMessage: function () {
    return {
      title: '我抽到了一个温暖的下班盲盒，来看看吧！',
      path: '/pages/share/share?type=' + this.data.resultType + '&historyId=' + this.data.historyId
    };
  },
  
  /**
   * 生命周期函数--监听页面显示
   */
  onShow: function() {
    // 设置页面导航栏返回按钮的行为
    wx.setNavigationBarTitle({
      title: '抽盲盒结果'
    });
  },
  
  /**
   * 自定义返回首页的方法
   */
  goBackHome: function() {
    wx.switchTab({
      url: '../index/index'
    });
  },
  
  /**
   * 拦截系统返回事件
   */
  onUnload: function() {
    // 手动控制页面栈，只保留首页
    const pages = getCurrentPages();
    if (pages.length > 1) {
      // 返回到首页，关闭当前页面
      wx.switchTab({
        url: '../index/index',
        success: function() {
          // 清除页面栈中除首页外的所有页面
          wx.navigateBack({ delta: pages.length - 1 });
        }
      });
    }
  }
})